home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Tools - Objects / MacApp / Unsupported Samples / CRC Cards / Source / UMyCommands.inc1.p < prev    next >
Encoding:
Text File  |  1990-07-12  |  29.0 KB  |  1,174 lines  |  [TEXT/MPS ]
  1. (**************************)
  2. (* methods for TMyCommand *)
  3. (**************************)
  4. {$S ADoCommand}
  5. PROCEDURE TMyCommand.IMyCommand(theCommandNum: CmdNumber; theCard: TCard);
  6.  
  7.     VAR
  8.         theDocument: TDesignDocument;
  9.         theView: TDesignView;
  10.         theScroller: TScroller;
  11.  
  12.     BEGIN
  13.         SELF.DetermineInitializationFromCard(theCard, theDocument, theView, theScroller);
  14.         SELF.ICommand(theCommandNum, theDocument, theView, theScroller);
  15.         SELF.SetDocument(theDocument);
  16.         SELF.SetCard(theCard);
  17.     END;    {TMyCommand.IMyCommnad}
  18.     
  19. {$S ADoCommand}
  20. FUNCTION TMyCommand.GetDocument: TDesignDocument;
  21.  
  22.     BEGIN
  23.         GetDocument:= fDocument;
  24.     END;    {TMyCommand.GetDocument}
  25.  
  26. {$S ADoCommand}
  27. PROCEDURE TMyCommand.SetDocument(theDesign: TDesignDocument);
  28.  
  29.     BEGIN
  30.         fDocument:= theDesign;
  31.     END;    {TMyCommand.SetDocument}
  32.  
  33. {$S ADoCommand}
  34. FUNCTION TMyCommand.GetCard: TCard;
  35.  
  36.     BEGIN
  37.         GetCard:= fCard;
  38.     END;    {TMyCommand.GetCard}
  39.  
  40. {$S ADoCommand}
  41. PROCEDURE TMyCommand.SetCard(theCard: TCard);
  42.  
  43.     BEGIN
  44.         fCard:= theCard;
  45.     END;    {TMyCommand.SetCard}
  46.  
  47. {$S ADoCommand}
  48. PROCEDURE TMyCommand.DetermineInitializationFromCard(    theCard: TCard;
  49.                                                                                                             VAR theDesignDoc: TDesignDocument;
  50.                                                                                                             VAR theDesignView: TDesignView;
  51.                                                                                                             VAR theScroller: TScroller);
  52.  
  53.     BEGIN
  54.         theDesignDoc:= theCard.GetDocument;
  55.         theDesignView:= theDesignDoc.GetDesignView;
  56.         theScroller:= theDesignView.GetScroller(kUseImmediateSuperView);
  57.     END;    {TMyCommand.DetermineInitializationFromCard}
  58.  
  59. {$S ADoCommand}
  60. PROCEDURE TMyCommand.RedoIt; OVERRIDE;
  61.  
  62.     BEGIN
  63.         SELF.DoIt;
  64.     END;    {TMyCommand.RedoIt}
  65.  
  66. {$S AFields}
  67. PROCEDURE TMyCommand.Fields(PROCEDURE DoToField(fieldName: Str255; fieldAddr: Ptr; 
  68.         fieldType: INTEGER)); OVERRIDE;
  69.  
  70.     BEGIN
  71.         DoToField('TMyCommand', NIL, bClass);
  72.         DoToField('fDocument', @fDocument, bObject);
  73.         DoToField('fCard', @fCard, bObject);
  74.         INHERITED Fields(DoToField);
  75.     END;    {TMyCommand.Fields}
  76.  
  77.  
  78. (*******************************)
  79. (* methods for TDraggerCommand *)
  80. (*******************************)
  81.  
  82. {$S ADoCommand}
  83. FUNCTION TDraggerCommand.GetSimpleView: TSimpleView;
  84.  
  85.     BEGIN
  86.         GetSimpleView:= fSimpleView;
  87.     END;    {TDraggerCommand.GetSimpleView}
  88.  
  89. {$S ADoCommand}
  90. PROCEDURE TDraggerCommand.SetSimpleView(theSimpleView: TSimpleView);
  91.  
  92.     BEGIN
  93.         fSimpleView:= theSimpleView;
  94.     END;    {TDraggerCommand.SetSimpleView}
  95.  
  96. {$S ADoCommand}
  97. FUNCTION TDraggerCommand.GetOldLocation: VPoint;
  98.  
  99.     BEGIN
  100.         GetOldLocation:= fOldLocation;
  101.     END;    {TDraggerCommand.GetOldLocation}
  102.  
  103. {$S ADoCommand}
  104. PROCEDURE TDraggerCommand.SetOldLocation(theLocation: VPoint);
  105.  
  106.     BEGIN
  107.         fOldLocation:= theLocation;
  108.     END;    {TDraggerCommand.SetOldLocation}
  109.  
  110. {$S ADoCommand}
  111. FUNCTION TDraggerCommand.GetNewLocation: VPoint;
  112.  
  113.     BEGIN
  114.         GetNewLocation:= fNewLocation;
  115.     END;    {TDraggerCommand.GetNewLocation}
  116.  
  117. {$S ADoCommand}
  118. PROCEDURE TDraggerCommand.SetNewLocation(theLocation: VPoint);
  119.  
  120.     BEGIN
  121.         fNewLocation:= theLocation;
  122.     END;    {TDraggerCommand.SetNewLocation}
  123.  
  124. {$S ADoCommand}
  125. PROCEDURE TDraggerCommand.IDraggerCommand(theView: TSimpleView; theDownPoint: Point);
  126.  
  127.     VAR
  128.         aLocation: VPoint;
  129.         theCard: TCard;
  130.  
  131.     BEGIN
  132.         theCard:= theView.GetCard;
  133.         aLocation:= theView.fLocation;
  134.         SELF.SetOldLocation(aLocation);    {MacApp does not provide the accessor!}
  135.         SELF.SetNewLocation(SELF.GetOldLocation);
  136.         SELF.SetSimpleView(theView);
  137.         theView.SetDragging(FALSE);
  138.         fConstrainsMouse:= kConstrainDrags;
  139.         SELF.IMyCommand(cMoveViewCmd, theCard);
  140.     END;    {TDraggerCommand.IDragger}
  141.     
  142. {$S ADoCommand}
  143. PROCEDURE TDraggerCommand.TrackFeedback(anchorPoint, nextPoint: VPoint;
  144.                             turnItOn, mouseDidMove: BOOLEAN); OVERRIDE;
  145.     
  146.     VAR
  147.         delta: Point;
  148.         itsFrame: VRect;
  149.         itsQDFrame: Rect;
  150.  
  151.     BEGIN
  152.         IF mouseDidMove AND (fSimpleView.GetDragging) THEN
  153.             BEGIN
  154.                 fSimpleView.GetFrame(itsFrame);
  155.                 VRectToRect(itsFrame, itsQDFrame);
  156.                 delta.h:= nextPoint.h - anchorPoint.h;
  157.                 delta.v:= nextPoint.v - anchorPoint.v;
  158.                 OffSetRect(itsQDFrame, delta.h, delta.v);
  159.                 PenMode(patXOR);
  160.                 FrameRect(itsQDFrame);
  161.             END;
  162.     END;    {TDraggerCommand.TrackFeedback}
  163.     
  164. {$S ADoCommand}
  165. FUNCTION TDraggerCommand.TrackMouse(aTrackPhase: TrackPhase; 
  166.                                                                         VAR anchorPoint, previousPoint, nextPoint: VPoint;
  167.                                                                          mouseDidMove: BOOLEAN): TCommand; OVERRIDE;
  168.     
  169.     VAR    
  170.         delta: VPoint;
  171.         newPoint: VPoint;
  172.         
  173.     BEGIN
  174.         TrackMouse:= SELF;
  175.         IF aTrackPhase = trackRelease THEN
  176.             BEGIN
  177.                 IF fSimpleView.GetDragging THEN
  178.                     BEGIN
  179.                         delta.h:= previousPoint.h - anchorPoint.h;
  180.                         delta.v:= previousPoint.v - anchorPoint.v;
  181.                         newPoint:= SELF.GetOldLocation;
  182.                         AddVPt(delta, newPoint);
  183.                         SELF.SetNewLocation(newPoint);
  184.                         fSimpleView.SetDragging(NOT kDragging);
  185.                     END
  186.                 ELSE
  187.                     TrackMouse:= gNoChanges;
  188.             END
  189.         ELSE
  190.             IF aTrackPhase = trackMove THEN
  191.                 IF mouseDidMove THEN
  192.                     IF (NOT fSimpleView.GetDragging) THEN
  193.                         BEGIN
  194.                             fSimpleView.GetWindow.Update;
  195.                             fSimpleView.SetDragging(kDragging);
  196.                             IF fSimpleView.FocusOnSuperView THEN;
  197.                         END;
  198.     END;    {TDraggerCommand.TrackMouse}
  199.  
  200. {$S ADoCommand}
  201. PROCEDURE TDraggerCommand.DoIt; OVERRIDE;
  202.  
  203.     VAR
  204.         theLocation: VPoint;
  205.         theDesignView: TDesignView;
  206.  
  207.     BEGIN
  208.         theLocation:= SELF.GetNewLocation;
  209.         IF theLocation.h < 0 THEN
  210.             theLocation.h:= 0;
  211.         IF theLocation.v < 0 THEN
  212.             theLocation.v:= 0;
  213.         fSimpleView.Locate(theLocation.h, theLocation.v, kInvalidate);
  214.         theDesignView:= fDocument.GetDesignView;
  215.         theDesignView.AdjustSize;
  216.         fCard.SetLocation(theLocation);
  217.     END;    {TAddCardCommand.DoIt}
  218.  
  219. {$S ADoCommand}
  220. PROCEDURE TDraggerCommand.UndoIt; OVERRIDE;
  221.  
  222.     VAR
  223.         theLocation: VPoint;
  224.         theDesignView: TDesignView;
  225.  
  226.     BEGIN
  227.         theLocation:= SELF.GetOldLocation;
  228.         IF theLocation.h < 0 THEN
  229.             theLocation.h:= 0;
  230.         IF theLocation.v < 0 THEN
  231.             theLocation.v:= 0;
  232.         fSimpleView.Locate(theLocation.h, theLocation.v, kInvalidate);
  233.         theDesignView:= fDocument.GetDesignView;
  234.         theDesignView.AdjustSize;
  235.         fCard.SetLocation(theLocation);
  236.     END;    {TAddCardCommand.UndoIt}
  237.  
  238. {$S AFields}
  239. PROCEDURE TDraggerCommand.Fields(PROCEDURE DoToField(fieldName: Str255; fieldAddr: Ptr; 
  240.         fieldType: INTEGER)); OVERRIDE;
  241.  
  242.     BEGIN
  243.         DoToField('TMyCommand', NIL, bClass);
  244.         DoToField('fSimpleView', @fSimpleView, bObject);
  245.         DoToField('fOldLocation', @fOldLocation, bVPoint);
  246.         DoToField('fNewLocation', @fNewLocation, bVPoint);
  247.         INHERITED Fields(DoToField);
  248.     END;    {TDraggerCommand.Fields}
  249.  
  250.  
  251. (****************************)
  252. (* methods for TCardCommand *)
  253. (****************************)
  254.  
  255.     {$S ARes}
  256.     FUNCTION TCardCommand.GetIndex: ArrayIndex;
  257.  
  258.         BEGIN
  259.             GetIndex:= fIndex;
  260.         END;    {TCardCommand.GetIndex}
  261.  
  262.     {$S ARes}
  263.     PROCEDURE TCardCommand.SetIndex(theIndex: ArrayIndex);
  264.  
  265.         BEGIN
  266.             fIndex:= theIndex;
  267.         END;    {TCardCommand.SetIndex}
  268.  
  269.     {$S ASelCommand}
  270.     PROCEDURE TCardCommand.ICardCommand(theCommandNum: CmdNumber; theCard: TCard; 
  271.                                                                             itsIndex: ArrayIndex);
  272.  
  273.         BEGIN
  274.             SELF.SetIndex(itsIndex);
  275.             SELF.IMyCommand(theCommandNum, theCard);
  276.         END;    {TCardCommand.ICardCommand}
  277.  
  278.     {$S AFields}
  279.     PROCEDURE TCardCommand.Fields(PROCEDURE DoToField(
  280.             fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  281.  
  282.         BEGIN
  283.             DoToField('TCardCommand', NIL, bClass);
  284.             DoToField('fIndex', @fIndex, bLongInt);
  285.             INHERITED Fields(DoToField);
  286.         END;    {TCardCommand.Fields}
  287.  
  288.  
  289. (*******************************)
  290. (* methods for TAddCardCommand *)
  291. (*******************************)
  292. {$S ADoCommand}
  293. PROCEDURE TAddCardCommand.IAddCardCommand(theLocation: Vpoint; 
  294.                     theDocument: TDesignDocument);
  295.                     
  296.     VAR
  297.         aCard: TCard;
  298.  
  299.     BEGIN
  300.         NEW(aCard);
  301.         FailNil(aCard);
  302.         aCard.ICard(theDocument, theLocation);
  303.         SELF.ICardCommand(cNewCardCmd, aCard, theDocument.GetNumCards + 1);
  304.     END;    {TAddCardCommand.IAddCardCommand}
  305.                     
  306. {$S ADoCommand}
  307. PROCEDURE TAddCardCommand.DoIt; OVERRIDE;
  308.  
  309.     BEGIN
  310.         fDocument.AddCard(fCard);
  311.     END;    {TAddCardCommand.DoIt}
  312.                     
  313. {$S ADoCommand}
  314. PROCEDURE TAddCardCommand.UndoIt; OVERRIDE;
  315.  
  316.     BEGIN
  317.         fDocument.DeleteCard(fCard);
  318.     END;    {TAddCardCommand.UndoIt}
  319.                     
  320. {$S AClose}
  321. PROCEDURE TAddCardCommand.Free; OVERRIDE;
  322.         
  323.     BEGIN
  324.         IF NOT(fCmdDone) THEN
  325.             fCard.Free;
  326.         INHERITED Free;
  327.     END;    {TAddCardCommand.Free}
  328.  
  329.  
  330. (**********************************)
  331. (* methods for TDeleteCardCommand *)
  332. (**********************************)
  333.                     
  334. {$S ADoCommand}
  335. PROCEDURE TDeleteCardCommand.IDeleteCardCommand(theCard: TCard; itsIndex: ArrayIndex);
  336.     BEGIN
  337.         SELF.ICardCommand(cDeleteCardCmd, theCard, itsIndex);
  338.     END; {TDeleteCardCommand.IDeleteCardCommand}
  339.                     
  340. {$S ADoCommand}
  341. PROCEDURE TDeleteCardCommand.DoIt; OVERRIDE;
  342.  
  343.     BEGIN
  344.         fDocument.DeleteCard(fCard);
  345.     END; {TDeleteCardCommand.DoIt}
  346.                     
  347. {$S ADoCommand}
  348. PROCEDURE TDeleteCardCommand.UndoIt; OVERRIDE;
  349.  
  350.     BEGIN
  351.         fDocument.AddCardAtIndex(fCard, SELF.GetIndex);
  352.     END; {TDeleteCardCommand.UndoIt}
  353.                     
  354. {$S AClose}
  355. PROCEDURE TDeleteCardCommand.Free; OVERRIDE;
  356.  
  357.     BEGIN
  358.         IF fCmdDone THEN
  359.             fCard.Free;
  360.         INHERITED Free;
  361.     END; {TDeleteCardCommand.Free}
  362.  
  363.  
  364. (*********************************)
  365. (* methods for TFieldItemCommand *)
  366. (*********************************)
  367.  
  368.     {$S ADoCommand}
  369.     PROCEDURE TFieldItemCommand.GetTheIndecies(VAR     theFieldIndex,
  370.                                                                                                     theGetIndex,
  371.                                                                                                     theSetIndex: ArrayIndex);
  372.  
  373.         BEGIN
  374.             theFieldIndex:= fFieldIndex;
  375.             theGetIndex:= fGetIndex;
  376.             theSetIndex:= fSetIndex;
  377.         END;
  378.  
  379.     {$S ADoCommand}
  380.     PROCEDURE TFieldItemCommand.SetTheIndecies(    theFieldIndex,
  381.                                                                                             theGetIndex,
  382.                                                                                             theSetIndex: ArrayIndex);
  383.  
  384.         BEGIN
  385.             fFieldIndex:= theFieldIndex;
  386.             fGetIndex:= theGetIndex;
  387.             fSetIndex:= theSetIndex;
  388.         END;
  389.  
  390.     {$S ADoCommand}
  391.     PROCEDURE TFieldItemCommand.DetermineAccessorsAndIndecies(theFieldItem: TFieldItem;
  392.                                                                                                                         theCard: TCard;
  393.                                                                                                                         itsIndex: ArrayIndex);
  394.             
  395.         VAR
  396.             theGetter: TGetAccessorItem; 
  397.             theSetter: TSetAccessorItem;
  398.             theGetIndex: ArrayIndex;
  399.             theSetIndex: ArrayIndex;
  400.             
  401.         BEGIN
  402.             theFieldItem.GetAccessors(theGetter, theSetter);
  403.             SELF.SetGetAccessor(theGetter);
  404.             theGetIndex:= theCard.GetIndexOfMethod(theGetter);    {kNotFound if theGetter = NIL}
  405.             SELF.SetSetAccessor(theSetter);
  406.             theSetIndex:= theCard.GetIndexOfMethod(theSetter);    {kNotFound if theGetter = NIL}
  407.             SELF.SetTheIndecies(itsIndex, theGetIndex, theSetIndex);
  408.         END;    {TFieldItemCommand.DetermineAccessors}
  409.         
  410.     {$S ADoCommand}
  411.     PROCEDURE TFieldItemCommand.IFieldItemCommand(theCommandNum: CmdNumber; 
  412.                                                                                                 theCard: TCard;
  413.                                                                                                 theFieldItem: TFieldItem;
  414.                                                                                                 itsIndex: ArrayIndex);
  415.             
  416.         BEGIN
  417.             SELF.SetFieldItem(theFieldItem);
  418.             SELF.SetTheIndecies(itsIndex, kNotFound, kNotFound);
  419.             SELF.IMyCommand(theCommandNum, theCard);
  420.         END;
  421.  
  422.     {$S ADoCommand}
  423.     FUNCTION TFieldItemCommand.GetFieldItem: TFieldItem;
  424.  
  425.         BEGIN
  426.             GetFieldItem:= fFieldItem;
  427.         END;
  428.  
  429.     {$S ADoCommand}
  430.     PROCEDURE TFieldItemCommand.SetFieldItem(theFieldItem: TFieldItem);
  431.  
  432.         BEGIN
  433.             fFieldItem:= theFieldItem;
  434.         END;
  435.  
  436.     {$S ADoCommand}
  437.     FUNCTION TFieldItemCommand.GetGetAccessor: TGetAccessorItem;
  438.  
  439.         BEGIN
  440.             GetGetAccessor:= fGetAccessor;
  441.         END;
  442.  
  443.     {$S ADoCommand}
  444.     PROCEDURE TFieldItemCommand.SetGetAccessor(theGetAccessor: TGetAccessorItem);
  445.  
  446.         BEGIN
  447.             fGetAccessor:= theGetAccessor;
  448.         END;
  449.  
  450.     {$S ADoCommand}
  451.     FUNCTION TFieldItemCommand.GetSetAccessor: TSetAccessorItem;
  452.  
  453.         BEGIN
  454.             GetSetAccessor:= fSetAccessor;
  455.         END;
  456.  
  457.     {$S ADoCommand}
  458.     PROCEDURE TFieldItemCommand.SetSetAccessor(theSetAccessor: TSetAccessorItem);
  459.  
  460.         BEGIN
  461.             fSetAccessor:= theSetAccessor;
  462.         END;
  463.  
  464.     
  465.     {$S ADoCommand}
  466.     PROCEDURE TFieldItemCommand.CreateAccessors(theFieldItem: TFieldItem);
  467.     
  468.         VAR
  469.             aGetAccessor: TGetAccessorItem;
  470.             aSetAccessor: TSetAccessorItem;
  471.             itsName: str255;
  472.     
  473.         BEGIN
  474.             itsName:= theFieldItem.GetTheName;
  475.             
  476.             NEW(aGetAccessor);
  477.             FailNIL(aGetAccessor);
  478.             aGetAccessor.IAccessorItem(fCard, itsName, theFieldItem);
  479.             SELF.SetGetAccessor(aGetAccessor);
  480.             theFieldItem.SetGetAccessor(aGetAccessor);
  481.             
  482.             NEW(aSetAccessor);
  483.             FailNIL(aSetAccessor);
  484.             aSetAccessor.IAccessorItem(fCard, itsName, theFieldItem);
  485.             SELF.SetSetAccessor(aSetAccessor);
  486.             theFieldItem.SetSetAccessor(aSetAccessor);
  487.         END;    {TFieldItemCommand.CreateAccessors}
  488.         
  489.     {$S ADoCommand}
  490.     PROCEDURE TFieldItemCommand.DeleteAccessors;
  491.     
  492.         BEGIN
  493.             IF fGetAccessor <> NIL THEN
  494.                 fCard.DeleteMethod(fGetAccessor);
  495.             IF fSetAccessor <> NIL THEN
  496.                 fCard.DeleteMethod(fSetAccessor);
  497.         END;    {TFieldItemCommand.DeleteAccessors}
  498.         
  499.     {$S AFields}
  500.     PROCEDURE TFieldItemCommand.Fields(PROCEDURE DoToField(
  501.             fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  502.  
  503.         BEGIN
  504.             DoToField('TFieldItemCommand', NIL, bClass);
  505.             DoToField('fFieldIndex', @fFieldIndex, bLongInt);
  506.             DoToField('fGetIndex', @fGetIndex, bLongInt);
  507.             DoToField('fSetIndex', @fSetIndex, bLongInt);
  508.             DoToField('fFieldItem', @fFieldItem, bObject);
  509.             DoToField('fGetAccessor', @fGetAccessor, bObject);
  510.             DoToField('fSetAccessor', @fSetAccessor, bObject);
  511.             INHERITED Fields(DoToField);
  512.         END;
  513.  
  514.  
  515. (************************************)
  516. (* methods for TAddFieldItemCommand *)
  517. (************************************)
  518.  
  519.     {$S ADoCommand}
  520.     PROCEDURE TAddFieldItemCommand.IAddFieldItemCommand(theCard: TCard;
  521.                                                                                                             theName, theType: str255);
  522.     
  523.         VAR
  524.             aFieldItem: TFieldItem;
  525.  
  526.         BEGIN
  527.             NEW(aFieldItem);
  528.             FailNIL(aFieldItem);
  529.             aFieldItem.IFieldItem(theCard, theName, theType);    
  530.             SELF.IFieldItemCommand(cAddFieldCmd, theCard, aFieldItem, theCard.GetNumFields + 1);
  531.             SELF.CreateAccessors(aFieldItem);
  532.         END;
  533.  
  534.     {$S ADoCommand}
  535.     PROCEDURE TAddFieldItemCommand.DoIt; OVERRIDE;
  536.  
  537.         BEGIN
  538.             fCard.AddMethod(fGetAccessor);
  539.             fCard.AddMethod(fSetAccessor);
  540.             fCard.AddField(fFieldItem);
  541.             fCard.SetupFieldsMode;
  542.         END;
  543.  
  544.     {$S ADoCommand}
  545.     PROCEDURE TAddFieldItemCommand.UndoIt; OVERRIDE;
  546.  
  547.         BEGIN
  548.             fCard.DeleteField(fFieldItem);
  549.             SELF.DeleteAccessors;
  550.         END;
  551.  
  552.     {$S AClose}
  553.     PROCEDURE TAddFieldItemCommand.Free; OVERRIDE;
  554.  
  555.         BEGIN
  556.             IF NOT(fCmdDone) THEN
  557.                 BEGIN
  558.                     fGetAccessor.Free;
  559.                     fSetAccessor.Free;
  560.                     fFieldItem.Free;
  561.                 END;
  562.             INHERITED Free;
  563.         END;
  564.  
  565.  
  566. (***************************************)
  567. (* methods for TDeleteFieldItemCommand *)
  568. (***************************************)
  569.  
  570.     {$S ADoCommand}
  571.     PROCEDURE TDeleteFieldItemCommand.IDeleteFieldItemCommand(theCard: TCard;
  572.                                                                                                                         theFieldItem: TFieldItem;
  573.                                                                                                                         itsIndex: ArrayIndex);
  574.  
  575.         BEGIN
  576.             SELF.IFieldItemCommand(cDelFieldCmd, theCard, theFieldItem, itsIndex);
  577.         END;
  578.  
  579.     {$S ADoCommand}
  580.     PROCEDURE TDeleteFieldItemCommand.DoIt; OVERRIDE;
  581.  
  582.         BEGIN
  583.             SELF.DetermineAccessorsAndIndecies(fFieldItem, fCard, fFieldIndex);
  584.             fCard.DeleteField(fFieldItem);
  585.             SELF.DeleteAccessors;
  586.             fCard.SetupFieldsMode;
  587.         END;
  588.  
  589.     {$S ADoCommand}
  590.     PROCEDURE TDeleteFieldItemCommand.UndoIt; OVERRIDE;
  591.  
  592.         BEGIN
  593.             fCard.AddFieldAtIndex(fFieldItem, fFieldIndex);
  594.             IF fGetAccessor <> NIL THEN
  595.                 fCard.AddMethodAtIndex(fGetAccessor, fGetIndex);
  596.             IF fSetAccessor <> NIL THEN
  597.                 fCard.AddMethodAtIndex(fSetAccessor, fSetIndex);
  598.         END;
  599.  
  600.     {$S AClose}
  601.     PROCEDURE TDeleteFieldItemCommand.Free; OVERRIDE;
  602.  
  603.         BEGIN
  604.             IF fCmdDone THEN
  605.                 BEGIN
  606.                     IF fGetAccessor <> NIL THEN
  607.                         fGetAccessor.Free;
  608.                     IF fSetAccessor <> NIL THEN
  609.                         fSetAccessor.Free;
  610.                     fFieldItem.Free;
  611.                 END;
  612.             INHERITED Free;
  613.         END;
  614.  
  615.  
  616. (**********************************)
  617. (* methods for TMethodItemCommand *)
  618. (**********************************)
  619.  
  620.     {$S ADoCommand}
  621.     FUNCTION TMethodItemCommand.GetIndex: ArrayIndex;
  622.  
  623.         BEGIN
  624.             GetIndex:= fIndex;
  625.         END;
  626.  
  627.     {$S ADoCommand}
  628.     PROCEDURE TMethodItemCommand.SetIndex(theIndex: ArrayIndex);
  629.  
  630.         BEGIN
  631.             fIndex:= theIndex;
  632.         END;
  633.  
  634.     {$S ADoCommand}
  635.     PROCEDURE TMethodItemCommand.IMethodItemCommand(theCommandNum: CmdNumber;
  636.                                                                                                     theCard: TCard;
  637.                                                                                                     theMethodItem: TMethodItem;
  638.                                                                                                     itsIndex: ArrayIndex);
  639.  
  640.         BEGIN
  641.             SELF.SetMethodItem(theMethodItem);
  642.             SELF.SetIndex(itsIndex);
  643.             SELF.IMyCommand(theCommandNum, theCard);
  644.         END;
  645.  
  646.     {$S ADoCommand}
  647.     FUNCTION TMethodItemCommand.GetMethodItem: TMethodItem;
  648.  
  649.         BEGIN
  650.             GetMethodItem:= fMethodItem;
  651.         END;
  652.  
  653.     {$S ADoCommand}
  654.     PROCEDURE TMethodItemCommand.SetMethodItem(theMethodItem: TMethodItem);
  655.  
  656.         BEGIN
  657.             fMethodItem:= theMethodItem;
  658.         END;
  659.  
  660.     {$S AFields}
  661.     PROCEDURE TMethodItemCommand.Fields(PROCEDURE DoToField(
  662.             fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  663.  
  664.         BEGIN
  665.             DoToField('TMethodItemCommand', NIL, bClass);
  666.             DoToField('fIndex', @fIndex, bLongInt);
  667.             DoToField('fMethodItem', @fMethodItem, bObject);
  668.             INHERITED Fields(DoToField);
  669.         END;
  670.  
  671.  
  672. (*************************************)
  673. (* methods for TAddMethodItemCommand *)
  674. (*************************************)
  675.  
  676.     {$S ADoCommand}
  677.     PROCEDURE TAddMethodItemCommand.IAddMethodItemCommand(theCard: TCard;
  678.                                                                                                                 theItemName: str255;
  679.                                                                                                                 makeItAnOverride: boolean);
  680.         VAR
  681.             aMethodItem: TMethodItem;
  682.             
  683.         BEGIN
  684.             NEW(aMethodItem);
  685.             FailNil(aMethodItem);
  686.             aMethodItem.IMethodItem(theCard, theItemName, makeItAnOverride);
  687.             SELF.IMethodItemCommand(cAddMethodCmd, theCard, aMethodItem, theCard.GetNumMethods + 1);
  688.         END;
  689.  
  690.     {$S ADoCommand}
  691.     PROCEDURE TAddMethodItemCommand.DoIt; OVERRIDE;
  692.  
  693.         BEGIN
  694.             fCard.AddMethod(fMethodItem);
  695.             fCard.SetupMethodsMode;
  696.         END;
  697.  
  698.     {$S ADoCommand}
  699.     PROCEDURE TAddMethodItemCommand.UndoIt; OVERRIDE;
  700.  
  701.         BEGIN
  702.             fCard.DeleteMethod(fMethodItem);
  703.         END;
  704.  
  705.     {$S AClose}
  706.     PROCEDURE TAddMethodItemCommand.Free; OVERRIDE;
  707.  
  708.         BEGIN
  709.             if NOT(fCmdDone) THEN
  710.                 fMethodItem.Free;
  711.             INHERITED Free;
  712.         END;
  713.  
  714.  
  715. (****************************************)
  716. (* methods for TDeleteMethodItemCommand *)
  717. (****************************************)
  718.  
  719.     {$S ADoCommand}
  720.     PROCEDURE TDeleteMethodItemCommand.IDeleteMethodItemCommand(theCard: TCard;
  721.                                                                                                                             theMethodItem: TMethodItem;
  722.                                                                                                                             itsIndex: ArrayIndex);
  723.  
  724.         BEGIN
  725.             SELF.SetMethodItem(theMethodItem);
  726.             SELF.IMethodItemCommand(cDelMethodCmd, theCard, theMethodItem, itsIndex);
  727.         END;
  728.  
  729.     {$S ADoCommand}
  730.     PROCEDURE TDeleteMethodItemCommand.DoIt; OVERRIDE;
  731.  
  732.         BEGIN
  733.             fCard.DeleteMethod(fMethodItem);
  734.             fCard.SetupMethodsMode;
  735.         END;
  736.  
  737.     {$S ADoCommand}
  738.     PROCEDURE TDeleteMethodItemCommand.UndoIt; OVERRIDE;
  739.  
  740.         BEGIN
  741.             fCard.AddMethodAtIndex(fMethodItem, fIndex);
  742.         END;
  743.  
  744.     {$S AClose}
  745.     PROCEDURE TDeleteMethodItemCommand.Free; OVERRIDE;
  746.  
  747.         BEGIN
  748.             IF fCmdDone THEN
  749.                 fMethodItem.Free;
  750.             INHERITED Free;
  751.         END;
  752.  
  753.  
  754. (*******************************************)
  755. (* methods for TAddCollaboratorItemCommand *)
  756. (*******************************************)
  757.  
  758.     {$S ASelCommand}
  759.     PROCEDURE TAddCollaboratorItemCommand.IAddCollaboratorItemCommand(theCard: TCard;
  760.                                                                                                                                         theItemName: str255);
  761.     
  762.         VAR
  763.             aCollaboratorItem: TCollaboratorItem;
  764.  
  765.         BEGIN
  766.             NEW(aCollaboratorItem);
  767.             FailNIL(aCollaboratorItem);
  768.             aCollaboratorItem.ICollaboratorItem(theCard, theItemName);
  769.             SELF.IFieldItemCommand(    cAddCollaboratorCmd, theCard, 
  770.                                                             aCollaboratorItem, theCard.GetNumCollaborators + 1);
  771.             SELF.CreateAccessors(aCollaboratorItem);
  772.         END;
  773.  
  774.     {$S ADoCommand}
  775.     PROCEDURE TAddCollaboratorItemCommand.DoIt; OVERRIDE;
  776.  
  777.         BEGIN
  778.             fCard.AddCollaborator(TCollaboratorItem(fFieldItem));
  779.             fCard.AddMethod(fGetAccessor);
  780.             fCard.AddMethod(fSetAccessor);
  781.             fCard.SetupCollaboratorsMode;
  782.         END;
  783.  
  784.     {$S ADoCommand}
  785.     PROCEDURE TAddCollaboratorItemCommand.UndoIt; OVERRIDE;
  786.  
  787.         BEGIN
  788.             fCard.DeleteCollaborator(TCollaboratorItem(fFieldItem));
  789.             fCard.DeleteMethod(fGetAccessor);
  790.             fCard.DeleteMethod(fSetAccessor);
  791.         END;
  792.  
  793.  
  794. (****************************************)
  795. (* methods for TDeleteCollabItemCommand *)
  796. (****************************************)
  797.  
  798.     {$S ASelCommand}
  799.     PROCEDURE TDeleteCollabItemCommand.IDeleteCollabItemCommand(theCard: TCard;
  800.                                                                                                                             theCollabItem: TCollaboratorItem;
  801.                                                                                                                             itsIndex: ArrayIndex);
  802.  
  803.         BEGIN
  804.             SELF.IFieldItemCommand(cDelFieldCmd, theCard, theCollabItem, itsIndex);
  805.         END;
  806.  
  807.     {$S ADoCommand}
  808.     PROCEDURE TDeleteCollabItemCommand.DoIt; OVERRIDE;
  809.  
  810.         BEGIN
  811.             SELF.DetermineAccessorsAndIndecies(fFieldItem, fCard, fFieldIndex);
  812.             fCard.DeleteCollaborator(TCollaboratorItem(fFieldItem));
  813.             IF fGetAccessor <> NIL THEN
  814.                 fCard.DeleteMethod(fGetAccessor);
  815.             IF fSetAccessor <> NIL THEN
  816.                 fCard.DeleteMethod(fSetAccessor);
  817.             fCard.SetupCollaboratorsMode;
  818.         END;
  819.  
  820.     {$S ADoCommand}
  821.     PROCEDURE TDeleteCollabItemCommand.UndoIt; OVERRIDE;
  822.  
  823.         BEGIN
  824.             fCard.AddCollaboratorAtIndex(TCollaboratorItem(fFieldItem), fFieldIndex);
  825.             IF fGetAccessor <> NIL THEN
  826.                 fCard.AddMethodAtIndex(fGetAccessor, fGetIndex);
  827.             IF fSetAccessor <> NIL THEN
  828.                 fCard.AddMethodAtIndex(fSetAccessor, fSetIndex);
  829.         END;
  830.  
  831.  
  832. (**********************************)
  833. (* methods for TChangeNameCommand *)
  834. (**********************************)
  835.  
  836. {$S ADoCommand}
  837. FUNCTION TChangeNameCommand.GetOldName: str255;
  838.  
  839.     BEGIN
  840.         GetOldName:= fOldName;
  841.     END;    {TChangeNameCommand.GetOldName}
  842.  
  843. {$S ADoCommand}
  844. PROCEDURE TChangeNameCommand.SetOldName(theOldName: str255);
  845.  
  846.     BEGIN
  847.         fOldName:= theOldName;
  848.     END;    {TChangeNameCommand.SetOldName}
  849.  
  850. {$S ADoCommand}
  851. FUNCTION TChangeNameCommand.GetNewName: str255;
  852.  
  853.     BEGIN
  854.         GetNewName:= fNewName;
  855.     END;    {TChangeNameCommand.GetNewName}
  856.  
  857. {$S ADoCommand}
  858. PROCEDURE TChangeNameCommand.SetNewName(theNewName: str255);
  859.  
  860.     BEGIN
  861.         fNewName:= theNewName;
  862.     END;    {TChangeNameCommand.SetNewName}
  863.  
  864. {$S ADoCommand}
  865. PROCEDURE TChangeNameCommand.IChangeNameCommand(theCommandNum: CmdNumber;
  866.                                                                                                 theCard: TCard; 
  867.                                                                                                 theOldName, theNewName: str255);
  868.  
  869.     BEGIN
  870.         SELF.SetOldName(theOldName);
  871.         SELF.SetNewName(theNewName);
  872.         SELF.IMyCommand(theCommandNum, theCard);
  873.     END;    {TChangeNameCommand.IChangeNameCommand}
  874.  
  875. {$S AFields}
  876. PROCEDURE TChangeNameCommand.Fields(PROCEDURE DoToField(fieldName: Str255; 
  877.                                                                         fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  878.     BEGIN
  879.         DoToField('TChangeNameCommand', NIL, bClass);
  880.         DoToField('fOldName', @fOldName, bString);
  881.         DoToField('fNewName', @fNewName, bString);
  882.         INHERITED Fields(DoToField);
  883.     END;    {TChangeNameCommand.Fields}
  884.  
  885.  
  886. (***********************************)
  887. (* methods for TChangeClassCommand *)
  888. (***********************************)
  889.  
  890. {$S ADoCommand}
  891. PROCEDURE TChangeClassCommand.DoIt; OVERRIDE;
  892.  
  893.     VAR
  894.         theName: str255;
  895.  
  896.     BEGIN
  897.         theName:= SELF.GetNewName;
  898.         fCard.ChangeClass(theName);
  899.     END;    {TChangeClassCommand.DoIt}
  900.  
  901. {$S ADoCommand}
  902. PROCEDURE TChangeClassCommand.UndoIt; OVERRIDE;
  903.  
  904.     VAR
  905.         theName: str255;
  906.  
  907.     BEGIN
  908.         theName:= SELF.GetOldName;
  909.         fCard.ChangeClass(theName);
  910.     END;    {TChangeClassCommand.UndoIt}
  911.  
  912.  
  913. (****************************************)
  914. (* methods for TChangeSuperClassCommand *)
  915. (****************************************)
  916.  
  917. {$S ADoCommand}
  918. PROCEDURE TChangeSuperClassCommand.DoIt; OVERRIDE;
  919.  
  920.     VAR
  921.         theName: str255;
  922.  
  923.     BEGIN
  924.         theName:= SELF.GetNewName;
  925.         fCard.ChangeSuperClass(theName);
  926.     END;    {TChangeSuperClassCommand.DoIt}
  927.  
  928. {$S ADoCommand}
  929. PROCEDURE TChangeSuperClassCommand.UndoIt; OVERRIDE;
  930.  
  931.     VAR
  932.         theName: str255;
  933.  
  934.     BEGIN
  935.         theName:= SELF.GetOldName;
  936.         fCard.ChangeSuperClass(theName);
  937.     END;    {TChangeSuperClassCommand.UndoIt}
  938.  
  939.  
  940. (*************************************)
  941. (* methods for TChangeInstVarCommand *)
  942. (*************************************)
  943.  
  944. {$S ADoCommand}
  945. PROCEDURE TChangeInstVarCommand.IChangeInstVarCommand(theCommandNum: CmdNumber; 
  946.                                                                                                                 theCard:TCard; 
  947.                                                                                                                 theFieldItem: TFieldItem;
  948.                                                                                                                 theNewName: Str255);
  949.                                                                                                     
  950. VAR
  951.     theGetAccessor: TGetAccessorItem;
  952.     theSetAccessor: TSetAccessorItem;
  953.  
  954. BEGIN
  955.     fFieldItem:=TheFieldItem;
  956.     SELF.IChangeNameCommand(theCommandNum, theCard, fFieldItem.GetTheName, theNewName);
  957.     fFieldItem.GetAccessors(theGetAccessor,theSetAccessor);
  958.     fGetAccessor:=theGetAccessor;
  959.     fSetAccessor:=theSetAccessor;
  960. END; {TChangeInstVarCommand.IChangeInstVarCommand}
  961.  
  962. {$S ADoCommand}
  963. PROCEDURE TChangeInstVarCommand.DoIt; OVERRIDE;
  964.  
  965.     VAR
  966.         theCard: TCard;
  967.         theCorrectName : Str255;
  968.         
  969.     BEGIN
  970.         theCard:=SELF.GetCard;
  971.         theCorrectName:= fFieldItem.GetTheName;
  972.         
  973.         {we must use this value, because it has now been adjusted to see if it already carries
  974.          the proper prefix in front, and that it has been stripped of all illegal characters.
  975.          NOTE!!! This assumes that the item's name already has it's new value!!!}
  976.         IF fGetAccessor<>NIL THEN
  977.             theCard.ChangeMethod(fGetAccessor,theCorrectName,FALSE);
  978.         IF fSetAccessor<>NIL THEN
  979.             theCard.ChangeMethod(fSetAccessor,theCorrectName,FALSE);
  980.     END;    {TChangeInstVarCommand.DoIt}
  981.  
  982. {$S ADoCommand}
  983. PROCEDURE TChangeInstVarCommand.UndoIt; OVERRIDE;
  984.  
  985.     VAR
  986.         theCard: TCard;
  987.         
  988.     BEGIN
  989.         theCard:=SELF.GetCard;
  990.         {THIS ASSUMES THE ITEM ITSELF HAS ALREADY BEEN RESTORED}
  991.         theCard.ChangeMethod(fGetAccessor,SELF.GetOldName,FALSE);
  992.         theCard.ChangeMethod(fSetAccessor,SELF.GetOldName,FALSE);
  993.     END;    {TChangeInstVarCommand.UndoIt}
  994.     
  995.     
  996. (***********************************)
  997. (* methods for TChangeFieldCommand *)
  998. (***********************************)
  999.  
  1000. {$S ADoCommand}
  1001. FUNCTION TChangeFieldCommand.GetOldType: Str255;
  1002.  
  1003.     BEGIN
  1004.         GetOldType:=fOldType;
  1005.     END;    {TChangeFieldCommand.GetOldType}
  1006.  
  1007. {$S ADoCommand}
  1008. PROCEDURE TChangeFieldCommand.SetOldType(theType: Str255);
  1009.  
  1010.     BEGIN
  1011.         fOldType:=theType;
  1012.     END;    {TChangeFieldCommand.SetOldType}
  1013.  
  1014. {$S ADoCommand}
  1015. FUNCTION TChangeFieldCommand.GetNewType: Str255;
  1016.  
  1017.     BEGIN
  1018.         GetNewType:=fNewType;
  1019.     END;    {TChangeFieldCommand.GetNewType}
  1020.  
  1021. {$S ADoCommand}
  1022. PROCEDURE TChangeFieldCommand.SetNewType(theType: Str255);
  1023.  
  1024.     BEGIN
  1025.         fNewType:=theType;
  1026.     END;    {TChangeFieldCommand.SetNewType}
  1027.  
  1028. {$S ADoCommand}
  1029. PROCEDURE TChangeFieldCommand.IChangeFieldCommand(theCommandNum: CmdNumber; theCard:TCard;
  1030.                                                                                                     TheFieldItem: TFieldItem;
  1031.                                                                                                     theNewName, theNewType: Str255);
  1032.                                                                                                     
  1033. BEGIN
  1034.     SELF.IChangeInstVarCommand(theCommandNum, theCard, TheFieldItem, theNewName);
  1035.     SELF.SetOldType(fFieldItem.GetItemType);
  1036.     SELF.SetNewType(theNewType);
  1037. END;
  1038.  
  1039. {$S ADoCommand}
  1040. PROCEDURE TChangeFieldCommand.DoIt; OVERRIDE;
  1041.     VAR
  1042.         theCard: TCard;
  1043.         
  1044.     BEGIN
  1045.         theCard:= SELF.GetCard;
  1046.         theCard.ChangeField(fFieldItem,SELF.GetNewName,SELF.GetNewType);
  1047.         INHERITED DoIt;
  1048.         theCard.SetupFieldsMode;
  1049.     END;    {TChangeFieldCommand.DoIt}
  1050.  
  1051. {$S ADoCommand}
  1052. PROCEDURE TChangeFieldCommand.UndoIt; OVERRIDE;
  1053.  
  1054.     VAR
  1055.         theCard: TCard;
  1056.         
  1057.     BEGIN
  1058.         SELF.GetCard.ChangeField(fFieldItem,SELF.GetOldName,SELF.GetOldType);
  1059.         INHERITED UndoIt
  1060.     END;    {TChangeFieldCommand.UndoIt}
  1061.     
  1062.  
  1063. (******************************************)
  1064. (* methods for TChangeCollaboratorCommand *)
  1065. (******************************************)
  1066.  
  1067. {$S ADoCommand}
  1068. PROCEDURE TChangeCollaboratorCommand.IChangeCollaboratorCommand(theCommandNum: CmdNumber; 
  1069.                                                                                                     theCard:TCard; 
  1070.                                                                                                     TheFieldItem: TFieldItem;
  1071.                                                                                                     theNewName: Str255);
  1072.                                                                                                     
  1073. BEGIN
  1074.     SELF.IChangeInstVarCommand(theCommandNum, theCard, theFieldItem, theNewName);
  1075. END;
  1076.  
  1077. {$S ADoCommand}
  1078. PROCEDURE TChangeCollaboratorCommand.DoIt; OVERRIDE;
  1079.  
  1080.     VAR
  1081.         theCard: TCard;
  1082.     
  1083.     BEGIN
  1084.         theCard:= SELF.GetCard;
  1085.         theCard.ChangeCollaborator(TCollaboratorItem(fFieldItem),SELF.GetNewName);
  1086.         INHERITED DoIt;
  1087.         theCard.SetupCollaboratorsMode;
  1088.     END;    {TChangeCollaboratorCommand.DoIt}
  1089.  
  1090. {$S ADoCommand}
  1091. PROCEDURE TChangeCollaboratorCommand.UndoIt; OVERRIDE;
  1092.  
  1093.     VAR
  1094.         theCard: TCard;
  1095.         
  1096.     BEGIN
  1097.         SELF.GetCard.ChangeCollaborator(TCollaboratorItem(fFieldItem),SELF.GetOldName);
  1098.         INHERITED UndoIt;
  1099.     END;    {TChangeCollaboratorCommand.UndoIt}
  1100.  
  1101.  
  1102. (******************************************)
  1103. (* methods for TChangeMethodCommand *)
  1104. (******************************************)
  1105.  
  1106. {$S ADoCommand}
  1107. FUNCTION TChangeMethodCommand.GetTheMethodItem:TMethodItem;
  1108. BEGIN
  1109.     GetTheMethodItem:=fMethodItem;
  1110. END; {TChangeMethodCommand.GetTheMethodItem}
  1111.  
  1112. {$S ADoCommand}
  1113. PROCEDURE TChangeMethodCommand.SetTheMethodItem(theMethodItem : TMethodItem);
  1114. BEGIN
  1115.     fMethodItem:=theMethodItem;
  1116. END; {TChangeMethodCommand.SetTheMethodItem}
  1117.  
  1118. {$S ADoCommand}
  1119. FUNCTION TChangeMethodCommand.GetOldIsOverride: Boolean;
  1120. BEGIN
  1121.     GetOldIsOverride:=fOldIsOverride;
  1122. END; {TChangeMethodCommand.GetOldIsOverride}
  1123.  
  1124. {$S ADoCommand}
  1125. PROCEDURE TChangeMethodCommand.SetOldIsOverride(isOverride : Boolean);
  1126. BEGIN
  1127.     fOldIsOverride:=isOverride;
  1128. END; {TChangeMethodCommand.SetOldIsOverride}
  1129.  
  1130. {$S ADoCommand}
  1131. FUNCTION TChangeMethodCommand.GetNewIsOverride:Boolean;
  1132. BEGIN
  1133.     GetNewIsOverride:=fNewIsOverride;
  1134. END; {TChangeMethodCommand.GetNewIsOverride}
  1135.  
  1136. {$S ADoCommand}
  1137. PROCEDURE TChangeMethodCommand.SetNewIsOverride(isOverride : Boolean);
  1138. BEGIN
  1139.     fNewIsOverride:=isOverride;
  1140. END; {TChangeMethodCommand.SetNewIsOverride}
  1141.  
  1142. {$S ADoCommand}
  1143. PROCEDURE TChangeMethodCommand.IChangeMethodCommand(theCommandNum: CmdNumber; 
  1144.                                                                                                     theCard:TCard; 
  1145.                                                                                                     theMethodItem: TMethodItem;
  1146.                                                                                                     theNewName: Str255;
  1147.                                                                                                     newIsOverride: Boolean);
  1148.                                                                                                     
  1149. BEGIN
  1150.     SELF.IChangeNameCommand(theCommandNum, theCard, theMethodItem.GetTheName, theNewName);
  1151.     SELF.SetTheMethodItem(theMethodItem);
  1152.     SELF.SetNewIsOverride(newIsOverride);
  1153.     SELF.SetOldIsOverride(theMethodItem.GetOVERRIDE);
  1154. END;
  1155.  
  1156. {$S ADoCommand}
  1157. PROCEDURE TChangeMethodCommand.DoIt; OVERRIDE;
  1158.  
  1159.     VAR
  1160.         theCard: TCard;
  1161.     
  1162.     BEGIN
  1163.         theCard:= SELF.GetCard;
  1164.         theCard.ChangeMethod(fMethodItem,SELF.GetNewName,SELF.GetNewIsOverride);
  1165.         theCard.SetupMethodsMode;
  1166.     END;    {TChangeMethodCommand.DoIt}
  1167.  
  1168. {$S ADoCommand}
  1169. PROCEDURE TChangeMethodCommand.UndoIt; OVERRIDE;
  1170.  
  1171.     BEGIN
  1172.         SELF.GetCard.ChangeMethod(fMethodItem,SELF.GetOldName,SELF.GetOldIsOverride);
  1173.     END;    {TChangeMethodCommand.UndoIt}
  1174.